// HTTP请求工具类优化封装
export const baseUrl = 'http://localhost:8888/'; // 基础URL
// const baseUrl = 'https://jxd.geetune.cn:8081/'; // 基础URL
// 默认请求头配置
const defaultHeaders = {
  'Content-Type': 'application/json'
};

// 请求拦截器
const requestInterceptor = (options) => {
  // 拼接完整URL
  if (!options.url.startsWith('http')) {
    options.url = baseUrl + options.url;
  }

  // 合并默认请求头与自定义请求头
  options.header = {
    ...defaultHeaders,
    ...options.header
  };

  // 可以在这里添加全局Token等信息
  const token = uni.getStorageSync('token');
  if (token) {
    options.header.Authorization = `Bearer ${token}`;
  }

  // 自动为除登录接口外的请求注入 openid（如果后端要求）
  // 可以通过在调用时传入 options.skipOpenid = true 来跳过注入
  try {
    // 支持通过 options.skipOpenid 或在 header 中设置 skipOpenid / X-Skip-Openid 来跳过注入
    let skip = options.skipOpenid || false
    if (!skip && options.header) {
      skip = !!(options.header.skipOpenid || options.header['X-Skip-Openid'])
      // 从 header 中移除该标识，避免发给后端
      if (options.header.skipOpenid) delete options.header.skipOpenid
      if (options.header['X-Skip-Openid']) delete options.header['X-Skip-Openid']
    }
    // 不在本地注入 openid 的接口白名单（如登录接口）
    const loginPaths = ['Mini/Minilogin', 'MiniAut/Minilogin', '/Mini/Minilogin']
    const isLoginCall = loginPaths.some(p => options.url.includes(p))

    if (!skip && !isLoginCall) {
      const data = options.data || {}
      const hasOpenid = data.OpenId || data.open_id || data.OpenId
      if (!hasOpenid) {
        // 先尝试从统一的 user 存储中读取
        const user = uni.getStorageSync('user') || {}
        const storedOpenid = user.OpenId || uni.getStorageSync('openid')
        if (storedOpenid) {
          options.data = { ...(options.data || {}), OpenId: storedOpenid }
        } else {
          // 无 openid：记录警告（不抛错，避免破坏流程）
          console.warn('http.requestInterceptor: 未找到 openid（请求可能需要登录）', options.url)
        }
      }
    }
  } catch (e) {
    // 忽略注入错误，继续请求；日志帮助调试
    console.warn('请求拦截器 openid 注入异常', e)
  }

  return options;
};

// 响应拦截器 - 修复后始终返回Promise
const responseInterceptor = (response) => {
  return new Promise((resolve, reject) => {
    if (response.statusCode === 200) {
      // 假设后端统一返回格式为 { code: 200, data: ..., message: ... }
      const { code, data, message } = response.data;
      if (code === 200) {
		  
        resolve(data.data); // 成功时解析数据
      } else if (code === 401) {
        // 统一处理未授权情况
        uni.removeStorageSync('token');
        uni.removeStorageSync('openid');
        uni.removeStorageSync('user');
        // 移除对不存在登录页面的跳转
        // 显示提示信息
        uni.showToast({
          title: '登录已过期，请重新登录',
          icon: 'none',
          duration: 3000
        });
        reject(new Error('登录已过期，请重新登录'));
      } else {
        uni.showToast({
          title: message || '操作失败',
          icon: 'none',
          duration: 3000
        });
        reject(new Error(message || '业务处理失败'));
      }
    } else {
      const errorMsg = `网络错误: ${response.statusCode}`;
      uni.showToast({
        title: errorMsg,
        icon: 'none',
        duration: 3000
      });
      reject(new Error(errorMsg));
    }
  });
};

// 通用请求方法封装
const request = (options) => {
  return new Promise((resolve, reject) => {
    // 应用请求拦截器
    const processedOptions = requestInterceptor({
      method: 'GET', // 默认GET方法
      ...options
    });

    uni.request({
      ...processedOptions,
      success: (response) => {
        // 现在responseInterceptor始终返回Promise，可以安全调用then
        responseInterceptor(response)
          .then(resolve)
          .catch(reject);
      },
      fail: (error) => {
        const errorMsg = error.errMsg || '请求失败，请稍后重试';
        uni.showToast({
          title: errorMsg,
          icon: 'none',
          duration: 3000
        });
        reject(new Error(errorMsg));
      }
    });
  });
};

// GET请求封装
export const get = (url, params = {}, header = {}) => {
  return request({
    url,
    method: 'GET',
    data: params, // GET请求参数放在data中，uni.request会自动转为query参数
    header
  });
};

// POST请求封装
export const post = (url, data = {}, header = {}) => {
  return request({
    url,
    method: 'POST',
    data,
    header
  });
};

// PUT请求封装
export const put = (url, data = {}, header = {}) => {
  return request({
    url,
    method: 'PUT',
    data,
    header
  });
};

// DELETE请求封装
export const del = (url, params = {}, header = {}) => {
  return request({
    url,
    method: 'DELETE',
    data: params,
    header
  });
};

export default {
  get,
  post,
  put,
  del,
  request, // 导出通用请求方法，方便特殊需求使用
  baseUrl // 导出baseUrl，方便其他地方使用
};
